ParametrizeCamera_FileAccess.py

Import File(s) to / Export File(s) from Camera(s)

It shows how to import file(s) to / export file(s) from camera(s), and get file access progress. The major steps include reading a file (such as UserSet1.bin) from camera by calling MV_CC_FileAccessRead(), writing a file (such as UserSet1.bin) to camera by calling MV_CC_FileAccessWrite(), and getting the progress of file access by calling MV_CC_GetFileAccessProgress().

# -- coding: utf-8 --

import time
import sys
import threading
import platform
import os
from ctypes import *

# Compatible with different operating systems to load DDL
currentsystem = platform.system()
if currentsystem == 'Windows':
    sys.path.append(os.path.join(os.getenv('MVCAM_COMMON_RUNENV'), "Samples", "Python", "MvImport"))
else:
    sys.path.append(os.path.join("..", "..", "MvImport"))
from MvCameraControl_class import *

# Compatible with input processing of Python 2.X and 3.X
if sys.version_info[0] < 3: 
    # Python 2.x
    input_func = raw_input
else: 
    # Python 3.x
    input_func = input

# Decoding Characters
def decoding_char(ctypes_char_array):
    """
    Safely decode a string from a ctypes character array.
    Compatible with Python 2.x and 3.x, as well as 32-bit and 64-bit environments.
    """
    byte_str = memoryview(ctypes_char_array).tobytes()
    
    # Truncate at the first null character
    null_index = byte_str.find(b'\x00')
    if null_index != -1:
        byte_str = byte_str[:null_index]
    
    # Attempt to decode using multiple encodings
    for encoding in ['gbk', 'utf-8', 'latin-1']:
        try:
            return byte_str.decode(encoding)
        except UnicodeDecodeError:
            continue
    
    # If all encodings fail, use a replacement strategy
    return byte_str.decode('latin-1', errors='replace')


# Define a function for ProgressThread
def progress_thread(cam=0, nMode=0):
    stFileAccessProgress = MV_CC_FILE_ACCESS_PROGRESS()
    memset(byref(stFileAccessProgress), 0, sizeof(stFileAccessProgress))
    while True:
        # Get the progress of file access
        ret = cam.MV_CC_GetFileAccessProgress(stFileAccessProgress)
        print ("State = [%x],Completed = [%d],Total = [%d]" % (ret, stFileAccessProgress.nCompleted, stFileAccessProgress.nTotal))
        if (ret != MV_OK or (stFileAccessProgress.nCompleted != 0 and stFileAccessProgress.nCompleted == stFileAccessProgress.nTotal)):
            print('press Enter key to continue.')
            break

# Define a function for FileAccessThread
def file_access_thread(cam=0, nMode=0):
    stFileAccess = MV_CC_FILE_ACCESS()
    memset(byref(stFileAccess), 0, sizeof(stFileAccess))
    stFileAccess.pUserFileName = 'UserSet1.bin'.encode('ascii')
    stFileAccess.pDevFileName = 'UserSet1'.encode('ascii')
    if 1 == nMode:
        # Read mode
        ret = cam.MV_CC_FileAccessRead(stFileAccess)
        if MV_OK != ret:
            print ("file access read fail ret [0x%x]\n" % ret)
    elif 2 == nMode:
        # Write mode
        ret = cam.MV_CC_FileAccessWrite(stFileAccess)
        if MV_OK != ret:
            print ("file access write fail ret [0x%x]\n" % ret)

if __name__ == "__main__":

    try:
        # Initialize SDK resources
        MvCamera.MV_CC_Initialize()
        
        SDKVersion = MvCamera.MV_CC_GetSDKVersion()
        print ("SDKVersion[0x%x]" % SDKVersion)
        
        deviceList = MV_CC_DEVICE_INFO_LIST()
        tlayerType = MV_GIGE_DEVICE | MV_USB_DEVICE
        
        # Enumerate devices
        ret = MvCamera.MV_CC_EnumDevices(tlayerType, deviceList)
        if ret != 0:
            print ("enum devices fail! ret[0x%x]" % ret)
            sys.exit()

        if deviceList.nDeviceNum == 0:
            print ("find no Device!")
            sys.exit()

        print ("find %d devices!" % deviceList.nDeviceNum)

        for i in range(0, deviceList.nDeviceNum):
            mvcc_dev_info = cast(deviceList.pDeviceInfo[i], POINTER(MV_CC_DEVICE_INFO)).contents
            if mvcc_dev_info.nTLayerType == MV_GIGE_DEVICE or mvcc_dev_info.nTLayerType == MV_GENTL_GIGE_DEVICE:
                print ("\ngige device: [%d]" % i)
                strModeName = decoding_char(mvcc_dev_info.SpecialInfo.stGigEInfo.chModelName)
                print ("device model name: %s" % strModeName)
                strSerialNumber = decoding_char(mvcc_dev_info.SpecialInfo.stGigEInfo.chSerialNumber)
                print("device serial number: %s" % strSerialNumber)
                nip1 = ((mvcc_dev_info.SpecialInfo.stGigEInfo.nCurrentIp & 0xff000000) >> 24)
                nip2 = ((mvcc_dev_info.SpecialInfo.stGigEInfo.nCurrentIp & 0x00ff0000) >> 16)
                nip3 = ((mvcc_dev_info.SpecialInfo.stGigEInfo.nCurrentIp & 0x0000ff00) >> 8)
                nip4 = (mvcc_dev_info.SpecialInfo.stGigEInfo.nCurrentIp & 0x000000ff)
                print ("current ip: %d.%d.%d.%d\n" % (nip1, nip2, nip3, nip4))
            elif mvcc_dev_info.nTLayerType == MV_USB_DEVICE:
                print ("\nu3v device: [%d]" % i)
                strModeName = decoding_char(mvcc_dev_info.SpecialInfo.stUsb3VInfo.chModelName)
                print ("device model name: %s" % strModeName)

                strSerialNumber =  decoding_char(mvcc_dev_info.SpecialInfo.stUsb3VInfo.chSerialNumber)                
                print ("device serial number: %s" % strSerialNumber)

        nConnectionNum = input_func("please input the number of the device to connect:")

        if int(nConnectionNum) >= deviceList.nDeviceNum:
            print ("intput error!")
            sys.exit()

        # Create the camera instance
        cam = MvCamera()
        
        # Select a device, and create a handle
        stDeviceList = cast(deviceList.pDeviceInfo[int(nConnectionNum)], POINTER(MV_CC_DEVICE_INFO)).contents

        ret = cam.MV_CC_CreateHandle(stDeviceList)
        if ret != 0:
            raise Exception ("create handle fail! ret[0x%x]" % ret)

        # Turn on the device
        ret = cam.MV_CC_OpenDevice(MV_ACCESS_Exclusive, 0)
        if ret != 0:
            raise Exception ("open device fail! ret[0x%x]" % ret)

        # Read mode
        print ("read to file.")
        print('press Enter key to start.')
        input_func()

        try:
            hReadThreadHandle = threading.Thread(target=file_access_thread, args=(cam, 1))
            hReadThreadHandle.start()
            time.sleep(0.005)
            hProgress1ThreadHandle = threading.Thread(target=progress_thread, args=(cam, 1))
            hProgress1ThreadHandle.start()
        except:
            raise Exception ("error: unable to start thread")

        print ("waiting.")
        input_func()

        hReadThreadHandle.join()
        hProgress1ThreadHandle.join()

        # Write mode
        print ("write from file.")
        print('press Enter key to start.')
        input_func()

        try:
            hWriteThreadHandle = threading.Thread(target=file_access_thread, args=(cam, 2))
            hWriteThreadHandle.start()
            time.sleep(0.005)
            hProgress2ThreadHandle = threading.Thread(target=progress_thread, args=(cam, 2))
            hProgress2ThreadHandle.start()
        except:
            raise Exception ("error: unable to start thread")

        print ("waiting.")
        input_func()

        hWriteThreadHandle.join()
        hProgress2ThreadHandle.join()

        # Turn off the device
        ret = cam.MV_CC_CloseDevice()
        if ret != 0:
            raise Exception ("close deivce fail! ret[0x%x]" % ret)


        # Destroy the handle
        ret = cam.MV_CC_DestroyHandle()

    except Exception as e:
        print(e)
        cam.MV_CC_CloseDevice()
        cam.MV_CC_DestroyHandle()
    finally:
        # Release SDK resources
        MvCamera.MV_CC_Finalize()